home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / UpdateManager / ChangelogViewer.py < prev    next >
Text File  |  2009-11-02  |  12KB  |  292 lines
  1. # ReleaseNotesViewer.py
  2. #  
  3. #  Copyright (c) 2006 Sebastian Heinlein
  4. #                2007 Canonical
  5. #  
  6. #  Author: Sebastian Heinlein <sebastian.heinlein@web.de>
  7. #          Michael Vogt <michael.vogt@ubuntu.com>
  8. #
  9. #  This modul provides an inheritance of the gtk.TextView that is 
  10. #  aware of http URLs and allows to open them in a browser.
  11. #  It is based on the pygtk-demo "hypertext".
  12. # 
  13. #  This program is free software; you can redistribute it and/or 
  14. #  modify it under the terms of the GNU General Public License as 
  15. #  published by the Free Software Foundation; either version 2 of the
  16. #  License, or (at your option) any later version.
  17. # 
  18. #  This program is distributed in the hope that it will be useful,
  19. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21. #  GNU General Public License for more details.
  22. # 
  23. #  You should have received a copy of the GNU General Public License
  24. #  along with this program; if not, write to the Free Software
  25. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  26. #  USA
  27.  
  28.  
  29. import pygtk
  30. import gtk
  31. import pango
  32. import subprocess
  33. import os
  34. from gettext import gettext as _
  35.  
  36. class ChangelogViewer(gtk.TextView):
  37.     def __init__(self, changelog=None):
  38.         """Init the ChangelogViewer as an Inheritance of the gtk.TextView"""
  39.         # init the parent
  40.         gtk.TextView.__init__(self)
  41.         # global hovering over link state
  42.         self.hovering = False
  43.         self.first = True
  44.         # setup the buffer and signals
  45.         self.set_property("editable", False)
  46.         self.set_cursor_visible(False)
  47.         # set some margin
  48.         self.set_right_margin(4)
  49.         self.set_left_margin(4)
  50.         self.set_pixels_above_lines(4)
  51.         self.buffer = gtk.TextBuffer()
  52.         self.set_buffer(self.buffer)
  53.         self.connect("button-press-event", self.button_press_event)
  54.         self.connect("motion-notify-event", self.motion_notify_event)
  55.         self.connect("visibility-notify-event", self.visibility_notify_event)
  56.         #self.buffer.connect("changed", self.search_links)
  57.         self.buffer.connect_after("insert-text", self.on_insert_text)
  58.         # search for links in the changelog and make them clickable
  59.         if changelog != None:
  60.             self.buffer.set_text(changelog)
  61.             
  62.     def create_context_menu(self, url):
  63.         """Create the context menu to be displayed when links are right clicked"""
  64.         self.menu = gtk.Menu()
  65.         
  66.         # create menu items
  67.         item_grey_link = gtk.MenuItem(url)
  68.         item_grey_link.connect("activate", self.handle_context_menu, "open", url)
  69.         item_seperator = gtk.MenuItem()
  70.         item_open_link = gtk.MenuItem(_("Open Link in Browser"))
  71.         item_open_link.connect("activate", self.handle_context_menu, "open", url)
  72.         item_copy_link = gtk.MenuItem(_("Copy Link to Clipboard"))
  73.         item_copy_link.connect("activate", self.handle_context_menu, "copy", url)
  74.         
  75.         # add menu items
  76.         self.menu.add(item_grey_link)
  77.         self.menu.add(item_seperator)
  78.         self.menu.add(item_open_link)
  79.         self.menu.add(item_copy_link)
  80.         self.menu.show_all()
  81.     
  82.     def handle_context_menu(self, menuitem, action, url):
  83.         """Handle activate event for the links' context menu"""
  84.         if action == "open":
  85.             self.open_url(url)
  86.         if action == "copy":
  87.             cb = gtk.Clipboard()
  88.             cb.set_text(url)
  89.             cb.store()
  90.  
  91.     def tag_link(self, start, end, url):
  92.         """Apply the tag that marks links to the specified buffer selection"""
  93.         tagged = False
  94.         tags = start.get_tags()
  95.         for tag in tags:
  96.             url = tag.get_data("url")
  97.             if url != "":
  98.                 return
  99.         tag = self.buffer.create_tag(None, foreground="blue",
  100.                                      underline=pango.UNDERLINE_SINGLE)
  101.         tag.set_data("url", url)
  102.         self.buffer.apply_tag(tag , start, end)
  103.  
  104.     def on_insert_text(self, buffer, iter_end, text, *args):
  105.         """Search for http URLs in newly inserted text  
  106.            and tag them accordingly"""
  107.  
  108.         # some convenient urls
  109.         MALONE = "https://launchpad.net/bugs/"
  110.         DEBIAN = "http://bugs.debian.org/"
  111.         CVE = "http://cve.mitre.org/cgi-bin/cvename.cgi?name="
  112.         # some convinient end-markers
  113.         ws = [" ","\t","\n"]
  114.         brak = [")","]",">"]
  115.         punct = [",","!",":"]
  116.         dot = ["."]+punct
  117.         dot_cr = [".\n"]
  118.  
  119.         # search items are start-str, list-of-end-strs, url-prefix
  120.         # a lot of this search is "TEH SUCK"(tm) because of limitations
  121.         # in iter.forward_search()
  122.         # - i.e. no insensitive searching, no regexp
  123.         search_items = [ ("http://", ws+brak+punct+dot_cr, "http://"),
  124.                          ("LP#", ws+brak+dot, MALONE),
  125.                          ("LP: #", ws+brak+dot, MALONE),
  126.                          ("lp: #", ws+brak+dot, MALONE),
  127.                          ("LP:#",  ws+brak+dot, MALONE),
  128.                          ("Malone: #", ws+brak+dot, MALONE),
  129.                          ("Malone:#", ws+brak+dot, MALONE),
  130.                          ("Ubuntu: #", ws+brak+dot, MALONE),
  131.                          ("Ubuntu:#", ws+brak+dot, MALONE),
  132.                          ("Closes: #",ws+brak+dot, DEBIAN),
  133.                          ("Closes:#",ws+brak+dot, DEBIAN),
  134.                          ("closes:#",ws+brak+dot, DEBIAN),
  135.                          ("closes: #",ws+brak+dot, DEBIAN),
  136.                          ("CVE-", ws+brak+dot, CVE),
  137.                        ]
  138.         # init
  139.         iter = buffer.get_iter_at_offset(iter_end.get_offset() - len(text))
  140.         iter_real_end = buffer.get_end_iter()
  141.  
  142.         # search for the next match in the buffer
  143.         for (start_str, end_list, url_prefix) in search_items:
  144.             while True:
  145.                 ret = iter.forward_search(start_str,
  146.                                           gtk.TEXT_SEARCH_VISIBLE_ONLY,
  147.                                           iter_end)
  148.                 # if we reach the end break the loop
  149.                 if not ret:
  150.                     break
  151.                 # get the position of the protocol prefix
  152.                 (match_start, match_end) = ret
  153.                 match_suffix = match_end.copy()
  154.                 match_tmp = match_end.copy()
  155.                 while True:
  156.                     # extend the selection to the complete search item
  157.                     if match_tmp.forward_char():
  158.                         text =  match_end.get_text(match_tmp)
  159.                         if text in end_list:
  160.                             break
  161.                         # move one char futher to get two char
  162.                         # end-markers (and back later) LP: #396393
  163.                         match_tmp.forward_char()
  164.                         text =  match_end.get_text(match_tmp)
  165.                         if text in end_list:
  166.                             break
  167.                         match_tmp.backward_char()
  168.                     else:
  169.                         break
  170.                     match_end = match_tmp.copy()
  171.  
  172.                 # call the tagging method for the complete URL
  173.                 url = url_prefix + match_suffix.get_text(match_end)
  174.  
  175.                 self.tag_link(match_start, match_end, url)
  176.                 # set the starting point for the next search
  177.                 iter = match_end
  178.  
  179.     def button_press_event(self, text_view, event):
  180.         """callback for mouse click events"""
  181.         # we only react on left or right mouse clicks
  182.         if event.button != 1 and event.button != 3:
  183.             return False
  184.  
  185.         # try to get a selection
  186.         try:
  187.             (start, end) = self.buffer.get_selection_bounds()
  188.         except ValueError:
  189.             pass
  190.         else:
  191.             if start.get_offset() != end.get_offset():
  192.                 return False
  193.  
  194.         # get the iter at the mouse position
  195.         (x, y) = self.window_to_buffer_coords(gtk.TEXT_WINDOW_WIDGET,
  196.                                               int(event.x), int(event.y))
  197.         iter = self.get_iter_at_location(x, y)
  198.         
  199.         # call open_url or menu.popup if an URL is assigned to the iter
  200.         tags = iter.get_tags()
  201.         for tag in tags:
  202.             url = tag.get_data("url")
  203.             if url != None:
  204.                 if event.button == 1: 
  205.                     self.open_url(url)
  206.                     break
  207.                 if event.button == 3:
  208.                     self.create_context_menu(url)
  209.                     self.menu.popup(None, None, None, event.button, event.time)
  210.                     return True
  211.  
  212.     def open_url(self, url):
  213.         """Open the specified URL in a browser"""
  214.         # Find an appropiate browser
  215.         if os.path.exists("/usr/bin/exo-open"):
  216.             command = ["exo-open", url]
  217.         elif os.path.exists('/usr/bin/gnome-open'):
  218.             command = ['gnome-open', url]
  219.         else:
  220.             command = ['x-www-browser', url]
  221.  
  222.         # Avoid to run the browser as user root
  223.         if os.getuid() == 0 and os.environ.has_key('SUDO_USER'):
  224.             command = ['sudo', '-u', os.environ['SUDO_USER']] + command
  225.  
  226.         subprocess.Popen(command)
  227.  
  228.     def motion_notify_event(self, text_view, event):
  229.         """callback for the mouse movement event, that calls the
  230.            check_hovering method with the mouse postition coordiantes"""
  231.         x, y = text_view.window_to_buffer_coords(gtk.TEXT_WINDOW_WIDGET,
  232.                                                  int(event.x), int(event.y))
  233.         self.check_hovering(x, y)
  234.         self.window.get_pointer()
  235.         return False
  236.     
  237.     def visibility_notify_event(self, text_view, event):
  238.         """callback if the widgets gets visible (e.g. moves to the foreground)
  239.            that calls the check_hovering method with the mouse position
  240.            coordinates"""
  241.         (wx, wy, mod) = text_view.window.get_pointer()
  242.         (bx, by) = text_view.window_to_buffer_coords(gtk.TEXT_WINDOW_WIDGET, wx,
  243.                                                      wy)
  244.         self.check_hovering(bx, by)
  245.         return False
  246.  
  247.     def check_hovering(self, x, y):
  248.         """Check if the mouse is above a tagged link and if yes show
  249.            a hand cursor"""
  250.         _hovering = False
  251.         # get the iter at the mouse position
  252.         iter = self.get_iter_at_location(x, y)
  253.         
  254.         # set _hovering if the iter has the tag "url"
  255.         tags = iter.get_tags()
  256.         for tag in tags:
  257.             url = tag.get_data("url")
  258.             if url != None:
  259.                 _hovering = True
  260.                 break
  261.  
  262.         # change the global hovering state
  263.         if _hovering != self.hovering or self.first == True:
  264.             self.first = False
  265.             self.hovering = _hovering
  266.             # Set the appropriate cursur icon
  267.             if self.hovering:
  268.                 self.get_window(gtk.TEXT_WINDOW_TEXT).\
  269.                         set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2))
  270.             else:
  271.                 self.get_window(gtk.TEXT_WINDOW_TEXT).\
  272.                         set_cursor(gtk.gdk.Cursor(gtk.gdk.LEFT_PTR))
  273.  
  274.  
  275. if __name__ == "__main__":
  276.     w = gtk.Window()
  277.     cv = ChangelogViewer()
  278.     changes = cv.get_buffer()
  279.     changes.create_tag("versiontag", weight=pango.WEIGHT_BOLD)
  280.     changes.set_text("""
  281.  
  282. Version 6-14-0ubuntu1.9.04:
  283.  
  284.   * New upstream version. LP: #382918.
  285.     Release notes at http://java.sun.com/javase/6/webnotes/ReleaseNotes.html.
  286.  
  287. """)
  288.  
  289.     w.add(cv)
  290.     w.show_all()
  291.     gtk.main()
  292.